// 详情模块
import moment from 'moment-timezone'
import getTz from '@/static/js/get-tz'
import $store from '@/store/index'

const store = {
    state: {
        dataPosition: 0, // 设置数据的索引
        recordData: [], // 记录数据
        summarize: {}, // 概览数据
        dateOptions: [], // 日期选择下拉框列表
        listData: [], // 列表数据
        bleLoadList: [], // 读取的数据
        readList: [], // 读取列表
        loadState: 0 // 列表数据加载状态（0： 可加载， 1：加载中 2：到底了）
    },
    getters: {
        // 折线图
        lineChartData(state) {
            const data = state.recordData
            let time = []
            let value = []
            data.forEach(item => {
                time.push(item.time)
                value.push(item.value)
            })

            return {
                time: time,
                value: value
            }
        },
        // 概述
        summarizeData(state) {
            const unit = $store.state['global-config'].temperatureUnit // 单位
            let data = state.summarize
            data.tempList = data.tempList || [] // 防止无数据报错
            const tz = data.timezone || getTz() // 网络查询的数据未记录时区，在getTz方法里判断当前时区
            const time = (data.startRecTime - tz * 3600) * 1000 + Date.UTC(2000, 0, 1)
            const start = moment(time).format('YYYY-MM-DD HH:mm:ss')
            const startUNIX = moment(start).unix()
            const endUNIX = startUNIX + (data.interval1 * (data.qty - 1)) * 60
            const end = moment(endUNIX * 1000).format('YYYY-MM-DD HH:mm:ss')
            const startTempAndTime = data.tempList.length ? `${data.tempList[0]}${unit}/${start}` : ''
            const endTempAndTime = data.tempList.length ? `${data.tempList[data.tempList.length - 1]}${unit}/${end}` : ''
            const recordData = state.recordData
            const maxTempAndTime = recordData.filter(item => item.value == data.maxTemperature)
            const minTempAdnTime = recordData.filter(item => item.value == data.minTemperature)

            return {
                // 记录时长
                mid: data.mid, // 设备ID
                notes: data.notes || '', // 备注
                trackID: data.trackID || '', // 运单
                boxID: data.boxID || '', // 箱号
                downTemperature: data.downTemperature + unit || '', // 温度上限
                upTemperature: data.upTemperature + unit || '',// 温度下限
                interval1: data.interval1 || '', // 记录间隔
                temperatureUnit: unit || '', // 温度单位
                // 启动方式
                recDelay: data.recDelay || '', // 延时时间
                avgTemperature: data.avgTemperature ? data.avgTemperature.toFixed(1) + unit : '', // 平均温度
                qty: data.qty || '', // 记录数量
                maxTempAndTime: maxTempAndTime.length ? `${maxTempAndTime[0].value}${unit}/${maxTempAndTime[0].time}` : '', // 最大温度/时间
                minTempAdnTime: minTempAdnTime.length ? `${minTempAdnTime[0].value}${unit}/${minTempAdnTime[0].time}` : '', // 最小温度/时间
                startTempAndTime: startTempAndTime || '', // 开始时间和温度
                endTempAndTime: endTempAndTime || '', // 结束时间和温度
                // TODO 记录时长
                tempTime: data.tempTime // 记录时间，该时间减去第一条时间计算记录了多久
            }
        }
    },
    mutations: {
        // 设置记录数组
        SET_RECORD_DATA(state, arr) {
            state.recordData = arr
            console.log('设置查询列数据', state.recordData)
        },
        // 设置概览数据
        SET_SUMMARIZE(state, data) {
            state.summarize = Object.assign({}, data)
            console.log('设置概览数据数据', state.summarize)
        },
        // 设置数据列表日期选择选项
        SET_DATE_OPTIONS(state, data) {
            state.dateOptions = data
        },
        // 一级数据列表更新
        SET_LIST_DATA(state, data) {
            state.listData = data
            console.log('设置一级数据列表', data)
        },
        UP_LIST_LV1(state, data) {
            state.listData.push(data)
        },
        // 二级数据列表更新
        UP_LIST_LV2(state, data) {
            state.listData[data.index].children.push(data.data)
        },
        // 设置数据加载的位置
        SET_DATA_POSITION(state, pos) {
            state.dataPosition = pos
        },
        // 设置加载状态
        SET_LOAD_STATE(state, status) {
            state.loadState = status
        },
        // 设置蓝牙读取的数据
        LOAD_LIST_PUTSH(state, data) {
            Object.assign(state.bleLoadList[data.index], data.data)
        },
        // 更新蓝牙读取的数据
        // 设置读取列表
        SET_READ_LIST(state, data) {
            state.readList.push(data)
        },
        // 更新读取列表
        UP_READ_LIST(state, data) {
            Object.assign(state.readList[data.index], data.data)
        }
    },
    actions: {
        // 设置读取的列表
        setReadList({ commit, state }, data) {
            const list = state.readList
            const index = list.findIndex(item => item.mid == data.mid)
            if (index < 0) {
                commit('SET_READ_LIST', data)
            } else {
                commit('UP_READ_LIST', { data: data, index: index })
            }
        },
        // 解析数据
        detailsDataHandler({ commit }, data) {
            let arr = []
            let tempList = data.tempList || (Array.isArray(data.startToReadTemp) ? data.startToReadTemp : data.startToReadTemp.split(','))
            let tempTime = moment(data.tempTime).format('X') // 记录时间unix
            // 初始记录时间按照数据的顺序 + 记录间隔 = 记录时间列表
            tempList.forEach((item, index) => {
                let currentTime = Number(tempTime) + index * Number(data.interval1) * 60
                arr.push({
                    'time': moment.unix(currentTime).format('YYYY-MM-DD HH:mm:ss'),
                    'value': item,
                    'serialId': index + 1
                })
            })
            commit('SET_RECORD_DATA', arr) // 设置记录数据
            if (data.startToReadTemp) {
                delete data.startToReadTemp // 删除原数组中的记录数据
            }
            data.tempList = tempList
            commit('SET_SUMMARIZE', data) // 设置概览数据
        },
        /**
         * 设置列表数据
         * 长列表渲染造成页面卡顿，故使用切割方式需要多少数据加载多少
         */
        listHandler({ commit, state }) {
            commit('SET_LOAD_STATE', 1) // 设置状态加载中
            const n = state.dataPosition
            const m = n + 20
            const data = state.recordData.reverse() // 反转
            const arr = data.slice(n, m)
            let list = state.listData
            console.log('列数据', data)
            console.log('加载位置', n, m)
            // 判断是否加载完毕，加载完毕不继续执行
            if (m == data.leng - 1) {
                commit('SET_LOAD_STATE', 2)
                return false
            }
            // 首次设置列表数据
            if (!list.length) {
                let obj = {}
                arr.forEach(item => {
                    let time = moment(item.time).format('YYYY-MM-DD')
                    if (!obj[time]) {
                        obj[time] = {
                            time,
                            children: []
                        }
                    }
                    obj[time].children.push(item)
                })
                let res = Object.values(obj)
                commit('SET_LIST_DATA', res)
            } else {
                // 加载
                // TODO 不知为何上边定义的arr在第二次加载失效
                let arr = data.reverse().slice(n, m)
                arr.forEach((item, index) => {
                    let time = moment(item.time).format('YYYY-MM-DD')
                    let findIndex = list.findIndex(val => val.time == time)
                    if (findIndex > -1) {
                        // 二级数据设置
                        commit('UP_LIST_LV2', { index: findIndex, data: item })
                    } else {
                        // 一级数据设置
                        commit('UP_LIST_LV1', { time: time, children: [item] })
                    }
                })
            }
            commit('SET_LOAD_STATE', 0) // 设置状态可加载
            commit('SET_DATA_POSITION', m) // 设置记录位置
        },
        // 根据日期过滤数据
        filterData({ commit, state }, day) {
            const list = state.listData
            const currentData = list.filter(val => val.time == day)
            if (!currentData.length) {
                const data = state.recordData.reverse()
                let arr = data.filter(val => moment(val.time).format('YYYY-MM-DD') == day)
                let res = [
                    {
                        time: day,
                        children: arr
                    }
                ]
                commit('SET_LIST_DATA', res)
            } else {
                commit('SET_LIST_DATA', currentData[0])
            }
        },
        // 设置日期选择
        setDateOptions({ commit, state }) {
            let arr = state.recordData
            let list = []
            arr.forEach(item => {
                let time = moment(item.time).format('YYYY-MM-DD')
                if (!list.includes(time)) {
                    list.push(time)
                }
            })
            commit('SET_DATE_OPTIONS', list.reverse())
        },
        // 设置蓝牙读取的详细数据列表
        onLoadListHandler({ commit, state }, data) {
            const list = state.bleLoadList
            const index = list.findIndex(item => item.deviceId == data.deviceId)
            if (index > 0) {
                commit('LOAD_LIST_PUTSH', { index: index, data: data })
            } else {
                commit('LOAD_LIST_PUTSH', data)
            }
        }
    }
}

export default store